TypeScript Sigurnost: Tipski uzorci sanitizacije unosa za robusne aplikacije

U današnjem međusobno povezanom svijetu, izgradnja sigurnih i pouzdanih web aplikacija je od najveće važnosti. S povećanjem sofisticiranosti cyber prijetnji, programeri moraju primijeniti robusne sigurnosne mjere kako bi zaštitili osjetljive podatke i spriječili zlonamjerne napade. TypeScript, sa svojim snažnim tipskim sustavom, pruža moćne alate za poboljšanje sigurnosti aplikacija, posebno kroz tipske uzorke sanitizacije unosa. Ovaj sveobuhvatni vodič istražuje različite TypeScript tipske uzorke za sanitizaciju unosa, omogućujući vam da izgradite sigurnije i otpornije aplikacije.

Zašto je sanitizacija unosa ključna

Sanitizacija unosa je proces čišćenja ili modificiranja podataka koje unosi korisnik kako bi se spriječilo da uzrokuju štetu aplikaciji ili njezinim korisnicima. Nepouzdani podaci, bilo iz obrazaca, API zahtjeva ili bilo kojeg drugog vanjskog izvora, mogu uvesti ranjivosti kao što su:

• Cross-Site Scripting (XSS): Napadači ubacuju zlonamjerne skripte u web stranice koje gledaju drugi korisnici.
• SQL Injection: Napadači umeću zlonamjerni SQL kod u upite baze podataka.
• Command Injection: Napadači izvršavaju proizvoljne naredbe na poslužitelju.
• Path Traversal: Napadači pristupaju neovlaštenim datotekama ili direktorijima.

Učinkovita sanitizacija unosa ublažava te rizike osiguravajući da su svi podaci koje aplikacija obrađuje u skladu s očekivanim formatima i da ne sadrže štetan sadržaj.

Iskorištavanje TypeScript tipskog sustava za sanitizaciju unosa

TypeScript tipski sustav nudi nekoliko prednosti za implementaciju sanitizacije unosa:

• Statička analiza: TypeScript kompajler može otkriti potencijalne pogreške povezane s tipovima tijekom razvoja, prije izvođenja.
• Tipska sigurnost: Prisiljava tipove podataka, smanjujući rizik od neočekivanih formata podataka.
• Jasnoća koda: Poboljšava čitljivost i održivost koda putem eksplicitnih deklaracija tipova.
• Podrška za refaktoriranje: Olakšava refaktoriranje koda uz održavanje tipske sigurnosti.

Iskorištavanjem TypeScript tipskog sustava, programeri mogu stvoriti robusne mehanizme sanitizacije unosa koji minimiziraju rizik od sigurnosnih ranjivosti.

Uobičajeni tipski uzorci sanitizacije unosa u TypeScriptu

1. Sanitizacija nizova znakova (String Sanitization)

Sanitizacija nizova znakova uključuje čišćenje i validaciju unesenih nizova znakova kako bi se spriječili XSS i drugi injection napadi. Evo nekoliko uobičajenih tehnika:

a. Izbjegavanje HTML entiteta

Izbjegavanje HTML entiteta pretvara potencijalno štetne znakove u njihove odgovarajuće HTML entitete, sprječavajući da se interpretiraju kao HTML kod. Na primjer, < postaje <, a > postaje >.

Primjer:

            
function escapeHtml(str: string): string {
  const map: { [key: string]: string } = {
    '&': '&',
    '<': '<',
    '>': '>',
    '"': '"',
    "'": '''
  };

  return str.replace(/[&<>\"']/g, (m) => map[m]);
}

const userInput: string = '';
const sanitizedInput: string = escapeHtml(userInput);
console.log(sanitizedInput); // Output: <script>alert("XSS");</script>

            

              
                Copy
              
            
          

b. Validacija regularnim izrazima

Regularni izrazi se mogu koristiti za validaciju da niz znakova odgovara određenom formatu, kao što je adresa e-pošte ili telefonski broj.

Primjer:

            
function isValidEmail(email: string): boolean {
  const emailRegex: RegExp = /^\w[\w-.]+@([\w-]+\.)+[\w-]{2,4}$/;
  return emailRegex.test(email);
}

const email1: string = 'test@example.com';
const email2: string = 'invalid-email';

console.log(isValidEmail(email1)); // Output: true
console.log(isValidEmail(email2)); // Output: false

            

              
                Copy
              
            
          

c. Alias tipova za specifične formate nizova znakova

TypeScript aliasi tipova se mogu koristiti za definiranje specifičnih formata nizova znakova i njihovo forsiranje u vrijeme kompajliranja.

Primjer:

            
type Email = string & { readonly __email: unique symbol };

function createEmail(input: string): Email {
  if (!isValidEmail(input)) {
    throw new Error('Invalid email format');
  }
  return input as Email;
}

try {
  const validEmail: Email = createEmail('test@example.com');
  console.log(validEmail); // Output: test@example.com (with type Email)

  const invalidEmail = createEmail('invalid-email'); //Throws error
} catch (error) {
  console.error(error);
}


            

              
                Copy
              
            
          

2. Sanitizacija brojeva

Sanitizacija brojeva uključuje validaciju da su uneseni brojevi unutar prihvatljivih raspona i da su u skladu s očekivanim formatima.

a. Validacija raspona

Osigurajte da broj pada unutar određenog raspona.

Primjer:

            
function validateAge(age: number): number {
  if (age < 0 || age > 120) {
    throw new Error('Invalid age: Age must be between 0 and 120.');
  }
  return age;
}

try {
  const validAge: number = validateAge(30);
  console.log(validAge); // Output: 30

  const invalidAge: number = validateAge(150); // Throws error

} catch (error) {
  console.error(error);
}


            

              
                Copy
              
            
          

b. Type Guards za tipove brojeva

Koristite type guards kako biste osigurali da je vrijednost broj prije izvođenja operacija nad njom.

Primjer:

            
function isNumber(value: any): value is number {
  return typeof value === 'number' && isFinite(value);
}

function processNumber(value: any): number {
  if (!isNumber(value)) {
    throw new Error('Invalid input: Input must be a number.');
  }
  return value;
}

try {
  const validNumber: number = processNumber(42);
  console.log(validNumber); // Output: 42

  const invalidNumber: number = processNumber('not a number'); // Throws error
} catch (error) {
  console.error(error);
}

            

              
                Copy
              
            
          

3. Sanitizacija datuma

Sanitizacija datuma uključuje validaciju da su uneseni datumi u ispravnom formatu i unutar prihvatljivih raspona.

a. Validacija formata datuma

Koristite regularne izraze ili biblioteke za parsiranje datuma kako biste osigurali da niz znakova datuma odgovara određenom formatu (npr. GGGG-MM-DD).

Primjer:

            
function isValidDate(dateString: string): boolean {
  const dateRegex: RegExp = /^\d{4}-\d{2}-\d{2}$/;
  if (!dateRegex.test(dateString)) {
    return false;
  }

  const date: Date = new Date(dateString);
  return !isNaN(date.getTime());
}

function parseDate(dateString: string): Date {
  if (!isValidDate(dateString)) {
    throw new Error('Invalid date format: Date must be in YYYY-MM-DD format.');
  }
  return new Date(dateString);
}

try {
  const validDate: Date = parseDate('2023-10-27');
  console.log(validDate); // Output: Fri Oct 27 2023 00:00:00 GMT+0000 (Coordinated Universal Time)

  const invalidDate: Date = parseDate('2023/10/27'); // Throws error
} catch (error) {
  console.error(error);
}

            

              
                Copy
              
            
          

b. Validacija raspona datuma

Osigurajte da datum pada unutar određenog raspona, kao što su početni i krajnji datum.

Primjer:

            
function isDateWithinRange(date: Date, startDate: Date, endDate: Date): boolean {
  return date >= startDate && date <= endDate;
}

function validateDateRange(dateString: string, startDateString: string, endDateString: string): Date {
  const date: Date = parseDate(dateString);
  const startDate: Date = parseDate(startDateString);
  const endDate: Date = parseDate(endDateString);

  if (!isDateWithinRange(date, startDate, endDate)) {
    throw new Error('Invalid date: Date must be between the start and end dates.');
  }
  return date;
}

try {
  const validDate: Date = validateDateRange('2023-10-27', '2023-01-01', '2023-12-31');
  console.log(validDate); // Output: Fri Oct 27 2023 00:00:00 GMT+0000 (Coordinated Universal Time)

  const invalidDate: Date = validateDateRange('2024-01-01', '2023-01-01', '2023-12-31'); // Throws error
} catch (error) {
  console.error(error);
}

            

              
                Copy
              
            
          

4. Sanitizacija nizova (Array Sanitization)

Sanitizacija nizova uključuje validaciju elemenata unutar niza kako bi se osiguralo da zadovoljavaju određene kriterije.

a. Type Guards za elemente niza

Koristite type guards kako biste osigurali da je svaki element u nizu očekivanog tipa.

Primjer:

            
function isStringArray(arr: any[]): arr is string[] {
  return arr.every((item) => typeof item === 'string');
}

function processStringArray(arr: any[]): string[] {
  if (!isStringArray(arr)) {
    throw new Error('Invalid input: Array must contain only strings.');
  }
  return arr;
}

try {
  const validArray: string[] = processStringArray(['apple', 'banana', 'cherry']);
  console.log(validArray); // Output: [ 'apple', 'banana', 'cherry' ]

  const invalidArray: string[] = processStringArray(['apple', 123, 'cherry']); // Throws error
} catch (error) {
  console.error(error);
}

            

              
                Copy
              
            
          

b. Sanitizacija elemenata niza

Primijenite tehnike sanitizacije na svaki element u nizu kako biste spriječili injection napade.

Primjer:

            
function sanitizeStringArray(arr: string[]): string[] {
  return arr.map(escapeHtml);
}

const inputArray: string[] = ['', 'normal text'];
const sanitizedArray: string[] = sanitizeStringArray(inputArray);
console.log(sanitizedArray);
// Output: [ '<script>alert("XSS");</script>', 'normal text' ]

            

              
                Copy
              
            
          

5. Sanitizacija objekata

Sanitizacija objekata uključuje validaciju svojstava objekta kako bi se osiguralo da zadovoljavaju određene kriterije.

a. Type Assertions za svojstva objekata

Koristite type assertions kako biste forsirali tipove svojstava objekata.

Primjer:

            
interface User {
  name: string;
  age: number;
  email: Email;
}

function validateUser(user: any): User {
  if (typeof user.name !== 'string') {
    throw new Error('Invalid user: Name must be a string.');
  }
  if (typeof user.age !== 'number') {
    throw new Error('Invalid user: Age must be a number.');
  }
  if (typeof user.email !== 'string' || !isValidEmail(user.email)) {
      throw new Error('Invalid user: Email must be a valid email address.');
  }

  return {
    name: user.name,
    age: user.age,
    email: createEmail(user.email)
  };
}

try {
  const validUser: User = validateUser({
    name: 'John Doe',
    age: 30,
    email: 'john.doe@example.com',
  });
  console.log(validUser);
  // Output: { name: 'John Doe', age: 30, email: [Email: john.doe@example.com] }

  const invalidUser: User = validateUser({
    name: 'John Doe',
    age: '30',
    email: 'invalid-email',
  }); // Throws error
} catch (error) {
  console.error(error);
}

            

              
                Copy
              
            
          

b. Sanitizacija svojstava objekata

Primijenite tehnike sanitizacije na svako svojstvo objekta kako biste spriječili injection napade.

Primjer:

            
interface Product {
  name: string;
  description: string;
  price: number;
}

function sanitizeProduct(product: Product): Product {
  return {
    name: escapeHtml(product.name),
    description: escapeHtml(product.description),
    price: product.price,
  };
}

const inputProduct: Product = {
  name: '',
  description: 'This is a product description with some HTML.',
  price: 99.99,
};

const sanitizedProduct: Product = sanitizeProduct(inputProduct);
console.log(sanitizedProduct);
// Output: { name: '<script>alert("XSS");</script>', description: 'This is a product description with some <b>HTML</b>.', price: 99.99 }

            

              
                Copy
              
            
          

Najbolje prakse za sanitizaciju unosa u TypeScriptu

• Sanitizirajte rano: Sanitizirajte podatke što je moguće bliže izvoru unosa.
• Koristite pristup obrane u dubini: Kombinirajte sanitizaciju unosa s drugim sigurnosnim mjerama, kao što su izlazno kodiranje i parametrizirani upiti.
• Održavajte logiku sanitizacije ažurnom: Budite informirani o najnovijim sigurnosnim ranjivostima i ažurirajte svoju logiku sanitizacije u skladu s tim.
• Testirajte svoju logiku sanitizacije: Temeljito testirajte svoju logiku sanitizacije kako biste osigurali da učinkovito sprječava injection napade.
• Koristite uspostavljene biblioteke: Iskoristite dobro održavane i pouzdane biblioteke za uobičajene zadatke sanitizacije, umjesto da izmišljate toplu vodu. Na primjer, razmislite o korištenju biblioteke kao što je validator.js.
• Razmotrite lokalizaciju: Kada imate posla s korisničkim unosom iz različitih regija, budite svjesni različitih skupova znakova i standarda kodiranja (npr. UTF-8). Osigurajte da vaša logika sanitizacije ispravno obrađuje te varijacije kako biste izbjegli uvođenje ranjivosti povezanih s problemima kodiranja.

Primjeri globalnih razmatranja unosa

Prilikom razvoja aplikacija za globalnu publiku, ključno je uzeti u obzir različite formate unosa i kulturne konvencije. Evo nekoliko primjera:

• Formati datuma: Različite regije koriste različite formate datuma (npr. MM/DD/GGGG u SAD-u, DD/MM/GGGG u Europi). Osigurajte da vaša aplikacija može obraditi više formata datuma i osigurati odgovarajuću validaciju.
• Formati brojeva: Različite regije koriste različite separatore za decimalna mjesta i tisuće (npr. 1.000,00 u SAD-u, 1.000,00 u Europi). Koristite odgovarajuće biblioteke za parsiranje i formatiranje za obradu tih varijacija.
• Simboli valuta: Simboli valuta razlikuju se od zemlje do zemlje (npr. $, €, £). Koristite biblioteku za formatiranje valuta za ispravan prikaz vrijednosti valuta na temelju korisničke lokalizacije.
• Formati adresa: Formati adresa značajno se razlikuju među zemljama. Osigurajte fleksibilna polja za unos i logiku validacije kako biste prilagodili različite strukture adresa.
• Formati imena: Formati imena razlikuju se među kulturama (npr. zapadna imena obično imaju ime, a zatim prezime, dok neke azijske kulture obrću redoslijed). Razmislite o tome da korisnicima dopustite da odrede željeni redoslijed imena.

Zaključak

Sanitizacija unosa je kritičan aspekt izgradnje sigurnih i pouzdanih TypeScript aplikacija. Iskorištavanjem TypeScript tipskog sustava i implementacijom odgovarajućih tipskih uzoraka sanitizacije, programeri mogu značajno smanjiti rizik od sigurnosnih ranjivosti kao što su XSS i injection napadi. Zapamtite da sanitizirate rano, koristite pristup obrane u dubini i budite informirani o najnovijim sigurnosnim prijetnjama. Prateći ove najbolje prakse, možete izgraditi robusnije i sigurnije aplikacije koje štite vaše korisnike i njihove podatke. Prilikom izgradnje globalnih aplikacija, uvijek imajte na umu kulturne konvencije kako biste osigurali pozitivno korisničko iskustvo.

Ovaj vodič pruža solidan temelj za razumijevanje i implementaciju sanitizacije unosa u TypeScriptu. Međutim, sigurnost je polje koje se neprestano razvija. Uvijek budite u tijeku s najnovijim najboljim praksama i ranjivostima kako biste učinkovito zaštitili svoje aplikacije.